Active element machine computation

ABSTRACT

An active element machine is a new kind of computing machine. When implemented in hardware, the Active element machine can execute multiple instructions simultaneously, because every one of its computing elements is active. This greatly enhances the computing speed. By executing a meta program whose instructions change the connections in a dynamic Active element machine, the Active element machine can perform tasks that digital computers are unable to compute.

FIELD

The subject matter of this specification has been influenced by Alan Turing's work in mathematics and computer science and Wilfred Rall's research in neurophysiology.

BACKGROUND

In a standard digital computer, the only active computing elements (which will be referred to as active elements) are specialized registers in the microprocessor. The active elements play a role in performing computations. Usually only one machine instruction can be computed at a time. This creates a computational bottleneck. The following references are incorporated herein by reference: [Adelman_(—)1] L. Adleman, “Molecular computation of solutions to combinatorial problems, ” Science v. 266, Nov. 1994, 1021-1024; [Adelman_(—)2] L. Adleman. On constructing a molecular computer, ftp://usc.edu/pub/csinfo/papers/adleman; [Bledsoe] Bledsoe, W. W. (1961), “The use of biological concepts in the analytical study of systems,” ORSA-TIMS National Meeting, San Francisco, Calif.; [Box] Box, G. E. P. (1957) “Evolutionary operation: A method for increasing industrial production,” Journal of the Royal Statistical Society, C, 6(2), 81-101; [Bremermann] Bremermann, R. J. (1962) “Optimization through evolution and recombination. Self-organizing systems,” pp. 93-106, Washington, D.C., Spartan Books; [Enderton] Enderton, Herbert B. (1972) A Mathematical Introduction to Logic, Academic Press, Inc., ISBN 0-12-238450-4, pp. 50-58; [Friedman] Friedman, G. J. (1959) “Digital simulation of an evolutionary process,” General Systems Yearbook, 4, pp. 171-184; [Gershenfeld], N. A. Gershenfeld and I. L. Chuang, “Bulk spin resonance quantum computation, ” Science 275 (1997), 350-356; [Kane], B. E. Kane, “A silicon-based nuclear spin quantum computer, ” Nature 393 (1998), pp. 133-137. [Kari], Lila Kari, “DNA computing: arrival of biological mathematics,” The Mathematical Intelligence, vol. 19, 2(1997), 9-22; [Mead] Mead, Carver, (1989) Analog VLSI and Neural Systems, Addison-Wesley Publishing Company, ISBN 0-201-05992-4; [Rall] Rall, Wilfrid. (1995) The Theoretical Foundation of Dendritic Function, MIT Press. ISBN 0-262-19356-6; [Shor] Peter Shor, Quantum Computing, Documenta Mathematica, Extra Volume ICM 1998, I, 467-486; [Turing] Turing, Alan M. (1936) “On Computable Numbers, with an Application to the Entscheidungsproblem,” Proceedings, London Mathematical Society, 2, no. 42, 230-265, and no. 43, 544-546.

BRIEF DESCRIPTION OF THE FIGURES

In the following drawings like reference numbers are used to refer to like elements. Although the following figures depict various examples of the invention, the invention is not limited to the examples depicted in the figures.

FIG. 1A show an example of a system of four active elements.

FIGS. 1B-J show plots of amplitudes of messages and an input function associated with the four active elements.

FIG. 2 shows an example of a directed graph that has a cycle and an example of a directed graph that does not have a cycle.

FIG. 3 shows an example of a machine in which the active elements are divided into modules to facilitate cyclic graph evolution.

FIG. 4 shows an example of how CGE executes a crossover between two machines.

FIG. 5 shows a graph of an example of a set of firing times for a set of active elements.

FIG. 6 shows an example of a circuit diagram of an active element.

FIG. 7 shows an amplifier behavior of a collection of transistors in FIG. 6, which is described in the specification.

DETAILED DESCRIPTION

Although various embodiments of the invention may have been motivated by various deficiencies with the prior art, which may be discussed or alluded to in one or more places in the specification, the embodiments of the invention do not necessarily address any of these deficiencies. In other words, different embodiments of the invention may address different deficiencies that may be discussed in the specification. Some embodiments may only partially address some deficiencies that may be discussed in the specification, and some embodiments may not address any of these deficiencies. Although this specification is divided into sections, nonetheless, there is no one location where all of the information of any element is necessarily located. Unique information about any particular element or any other aspect of any of the invention may be found in, or implied by, any part of the specification.

Active Elements

An active element is any element that is capable of performing computations; an “active element” is a computing element that is capable of both receiving and sending messages. Active computing elements can be any number of different types of elements. For example, an active element may be implemented with one or more registers that together are capable of sending and receiving messages. As an alternative to a register, an active element may be implemented as a collection of transistors, operating at subthreshold, and other electronic components, as will be discussed in conjunction with FIG. 6. At the quantum level, an active element may be a collection of one or more quantum gates, [Gershenfeld], [Kane], and [Shor]. An active element may be a collection of DNA that is designed to perform computations, [Adelman_(—)1], [Adelman_(—)2], and [Kari]. An active element may be an artificial neuron, composed of organic molecules such as a bi-lipid layer, with voltage-gated proteins embedded in the bi-lipid layer.

A collection of active elements may be assembled to form a computing machine. In this specification, the term “active” or “active element” is used in many places where in the parent application the term effector was used. The term “active element” is generic to, but broader than, the term “effector.”

Messages

In an embodiment, each message associated with an active element is a single pulse. In another embodiment, each message is composed of one or more pulses and/or other wave forms, and thus may be composed of a multiplicity of pulses. A machine may only allow active elements to send and/or receive one type of message or a multiplicity of types of messages.

Computing Machines Including One or More Collections of Active Elements

In an embodiment, a computing machine is constructed such that every computing element is active, and consequently any possible bottleneck is expected to be reduced because instead of only a small number of computing elements being able to participate in the computation any of the computing elements can participate in the computation. A computing machine having multiple active elements may be referred to as an active element machine (which is generic to an Effector machine). In an embodiment, the collection of active computing elements can execute multiple machine instructions simultaneously. The computing machine can be implemented in hardware and/or software. In an embodiment in which the computing machine is implemented in hardware, constructing a computing machine from a collection of active computing elements that can execute machine instructions simultaneously is expected to increase the computing speed over current digital computers for a large variety of computations. In another embodiment, the machine includes a multiplicity of active elements and also includes other computing elements.

Types of Active Elements

There are many different types of active elements that may be used to form a computing machine. In an embodiment, in a machine there are at least two kinds of active elements, which are input elements and output elements. In another embodiment there are also computational elements.

Input elements are capable of receiving, or receive, information from the environment (e.g., external sources), another machine, and/or a program, depending on the embodiment. Input elements may send messages to their selves, computational elements (if present), output elements, and/or other input elements, depending on the embodiment.

Computational elements are capable of receiving, or receive, messages from the input elements, and/or other computational elements, depending on the embodiment. A given computational element may send messages to itself, other computational elements, output elements, and/or input elements. The output elements receive messages from the input elements and computational elements (if computational elements are present). The output of the output elements represents the output of the machine.

Output elements may send messages to receptors external to the machine, itself, other computational elements, output elements, and/or input elements, depending on the embodiment. Receptors external to the machine may be other machines, other active elements that are not part of the machine or other types of receptors.

In the discussion below, the variables Γ, Λ, Δ represent index sets, used to index the input elements, computational elements, and output elements, respectively. Also, a set of input elements may be represented by the J, a set of computational elements may be represented by C, and a set of output elements may be represented by D. A machine including input elements J, computational elements C, and output elements D may be represented by M(J, C, D). For example, a machine M(J, C, D) consists of a collection of input active elements, denoted as J={E_(i): iεΓ}; a collection of computational active elements, C={E_(i): iεΛ}; and a collection of output active elements, D={E_(i): iεΔ}, where E_(i) is the ith active element and the symbol ε means “is an element of.” In other words, a machine may be characterized by the sets of active elements, J, C, and D, where J represents the set of active elements having indices that belong to the set Γ, and are therefore input elements; C represents the set of active elements having indices that belong to the set Λ, and are therefore computational elements; and D represents the set of active elements having indices that belong to the set Δ, and are therefore output elements.

Machine Architecture

The manner in which the active elements are capable of sending messages to one another is at least part of the architecture of the machine. In this specification, the active element that is sending the message may be referred to as the sender or as the sending active element, and the active element receiving the message may be referred to as the receiving active element or as the receiver. However, the sender may also be capable of being a receiver and the receiver may also be capable of being a sender. In an embodiment, when a sender is said to “fire” the sender sends a message to whichever set of receivers the sender is capable of sending a messages to. In another embodiment, it may be possible for a sender to selectively choose which receivers a given message is sent to, and to change the set of receivers a given message is sent to each time the sender fires.

In an embodiment in which the messages are composed of pulses or in which the messages have one or more amplitudes associated with them, the one or more amplitudes associated with the messages sent are dependent on both the receiver and the sender. Thus, for example, if a sender fires, a multitude of messages may be sent to a multitude of different receivers, respectively (each message may have a different set of one or more amplitudes). It is possible that a sender may fire, but the amplitudes associated with all of the messages (e.g., pulses) that are sent as a result of the firing are zero. Thus, despite the firing of a sender, the effect may be no different than no actual message being sent, because all of the messages that are sent as a result of the firing have an amplitude that is equal to zero. In another embodiment, the amplitude of a message may only be dependent on the receiver. In another embodiment, the amplitude of a message may only be dependent on the sender.

In different machine architectures different types of active elements (e.g., input elements Γ, computational elements Λ, and output elements Δ) are allowed to be connected to one another. Depending on the particular machine architecture, it is possible for the intersections Γ∩Λ and Λ∩Δ to be empty sets or non-empty sets, where the symbol ∩ is used to indicate the intersection of two sets. The intersection of two sets is the set of elements that is common to both sets. If Γ∩Λ is empty, then there are no active elements that belong to the set of input elements, Γ, and computational elements, Λ. Conversely, if Γ∩Λ is not empty, then there is at least one active element that is both an input element and a computational element. Similarly, if Λ∩Δ is empty, then there is no active element that are both a computational element and an output element, while if Λ∩Δ is not empty, then there is at least one active element that is both a computational element and an output element. In an embodiment, an active element, E_(i), can be an input element and a computational element. Likewise, in an embodiment, an active element can be an output element and a computational element. In this embodiment, when an output element, E_(i), is not a computational element, in other words when iεΔ, then E_(i) does not send messages to active elements in this machine.

Refractory Period

In an embodiment, each computational element and output element has a refractory period r_(i), where r_(i)>0, which is a period of time that must elapse after last sending a message before it may send another message. In other words, the refractory period, r_(i), is the amount of time that must elapse after active element E_(i) just fired and before active element E_(i) can fire again. In an alternative embodiment, refractory period r_(i) could be zero, and the active element could send a message simultaneously with receiving a message and/or could handle multiple messages simultaneously.

Message Amplitude and Width

In an embodiment, each computational element and output element may be associated with a collection of message amplitudes, {A_(ki)}_(kεΓ∪Λ), where the first of the two indices k and i denote the active element from which the message associated with amplitude A_(ki) is sent, and the second index denotes the active element receiving the message. The amplitude, A_(ki), represents the strength of the message that active element E_(k) transmits to active element E_(i) after active element E_(k) has fired. There are many different measures of amplitude that may be used for the amplitude of a message. For example, the amplitude of a message may be represented by the maximum value of the message or the root mean square height of the message. The same message may be sent to multiple active elements that are either computational elements or output elements, as indicated by the subscript εΓ∪Λ. However, each message may have a different amplitude A_(ki). Similarly, each message may be associated with its own message width, {ω_(ki)}_(kεΓ∪Λ), sent from active element E_(i) to E_(k), where ω_(ki)>0 for all kεΓ∪Λ. After a message reaches active E_(i), the message width ω_(ki) represents how long the message lasts as input to active element E_(i).

Threshold

In an embodiment, any given active element may be capable of sending and receiving a message, in response to receiving one or more messages, which when summed together, have an amplitude that is greater than a threshold associated with the active element. For example, if the messages are pulses, each computational and output active element, E_(i), may have a threshold, θ_(i), such that when a sum of the incoming pulses is greater than the threshold the active element fires (e.g., sends an output message). In an embodiment, when a sum of the incoming messages is lower than the threshold the active element does not fire. In another embodiment, it is possible to set the active element such that the active element fires when the sum of incoming messages is lower than the threshold; and when the sum of incoming messages is higher than the threshold, the active element does not fire.

In still another embodiment, there are two numbers α and θ where α≦θ and such that if the sum of the incoming messages lie in [α, θ], then the active element fires, but the active element does not fire if the sum lies outside of [α, θ]. In a variation of this embodiment, the active element fires if the sum of the incoming messages does not lie in [α, θ] and does not fire if the sum lies in [α, θ].

In another embodiment, the incoming pulses may be combined in other ways besides a sum. For example, if the product of the incoming pulses is greater than the threshold the active element may fire. Another alternative is for the active element to fire if the maximum of the incoming pulses is greater than the threshold. In still another alternative, the active element fires if the minimum of the incoming pulses is less than the threshold. In even another alternative if the convolution of the incoming pulses over some finite window of time is greater than the threshold, then the active element may fire.

Transmisson Time

In an embodiment, each computational and output element may be associated with collection of transmission times, {τ_(ki)}_(kεΓ∪Λ), where τ_(ki)>0 for all kεΓ∪Λ, which are the times that it takes a message to be sent from active element E_(k) to active element E_(i). The transmission time, τ_(ki), is the amount of time it takes for active element E_(i) to find out that active element E_(k) has fired. The transmission times, τ_(ki), may be chosen in the process of establishing the architecture.

Firing Function

In an embodiment, each active element is associated with a function of time, ψ_(i)(t), representing the time t at which active element E_(i) last fired. Mathematically, the function of time can be defined as ψ_(i)(t)=supremum {sεR: s<t AND g_(i)(s)=1}. The function ψ_(i)(t) always has the value of the last time that the active element fired. In general, throughout this specification the variable t is used to represent the current time, while in contrast s is used as variable of time that is not necessarily the current time.

Set of Firing Times and the Integrating Window

In an embodiment, each active element is associated with a function of time Ξ_(ki)(t), which is a set of recent firing times of active element E_(k) that are within active element E_(i)'s integrating window. In other words, the set of firing times Ξ_(ki)(t)={sεR: active element k fired at time s and 0≦t−S−τ_(ki)<ω_(ki)}. The integrating window is a duration of time during which the active element accepts messages. The integrating window may also be referred to as the window of computation. Other lengths of time could be chosen for the integrating window. In contrast to ψ_(i)(t), Ξ_(ki)(t) is not a function, but a set of values. Also, where as ψ_(i)(t) has a value as long as active element E_(i) fired at least once, Ξ_(ki)(t) does not have any values (is an empty set) if the last time that active element E_(i) fired is outside of the integrating window. In other words, if there are no firing times, s, that satisfy the inequality 0≦t−s−τ_(ki)<ω^(ki), then Ξ_(ki)(t) is the empty set. Let |Ξ_(ki)(t)| denote the number of elements in the set Ξ_(ki)(t). If Ξ_(ki)(t) is the empty set, then |Ξ_(ki)(t)|=0. Similarly, if Ξ_(ki)(t) has only one element in it then |Ξ_(ki)(t)|=1.

Input Function

In an embodiment, each input element and output element may have associated with it a collection of input functions, {Ø_(ki)(t)}_(kεΓ∪Λ). Each input function may be a function of time, and may represent messages coming from computational elements and input elements. The value of input function Ø_(ki)(t) is given by Ø^(ki)(t)=|Ξ_(ki)(t)|A_(ki), because each time a message from active element E_(k) reaches active element E_(i), the amplitude of the message is added to the last message. The number of messages inside the integrating window is the same as the value of |Ξ_(ki)(t)|. Since for a static machine the amplitude of the message sent from active element k to i is always the same value, A_(ki), therefore, the value Ø_(ki)(t) equals |Ξ_(ki)(t)|A_(ki).

Input elements that are not computational elements have the same characteristics as computational elements, except they have no input functions, Ø_(ki)(t), coming from active elements in this machine. In other words, input elements do not receive messages from active elements in the machine with which the input element is associated. In an embodiment, input elements are assumed to be externally firable. An externally firable element is an element that an external element or machine can cause to fire. In an embodiment, an external source such as the environment or an output element from another distinct machine, M′(J′; E′;D′) can cause an input element to fire. An input element can fire at any time as long as this time minus the time the input element last fired is greater than or equal to the input element's refractory period.

Output Function

An output function, g_(i)(t), may represent whether the active element fires at time t. The function g_(i)(t) is given by ${g_{i}(t)} = \left\{ {\begin{matrix} 1 & {if} & {{\sum\limits_{k \in {\Gamma\quad U\quad\Lambda}}{\varnothing_{ki}(t)}} > \theta_{i}} & {AND} & {{t - {\psi_{i}(t)}} \geq r_{i}} \\ 0 & {otherwise} & \quad & \quad & \quad \end{matrix}.} \right.$ In other words, if the sum of the input functions Ø_(ki)(t) is greater than the threshold, θ_(i), and time t is greater than or equal to the refractory period, r_(i), plus the time, ψ_(i)(t), that the active element last fired, then the active element E_(i) fires, and g_(i)(t)=1. If g_(i)(t₀)=1, then active element E_(i) fired at time t₀.

The fact that in an embodiment, output elements do not send messages to active elements in this machine is captured formally by the fact that the index k for the transmission times, message widths, message amplitudes, and input functions lies in Γ U Λ and not in Δ in that embodiment.

Connections

The expression “connection” from k to i represents the triplet (A_(ki); ω_(ki); τ_(ki)). If A_(ki)=0, then there is no connection from active element E_(k) to active element E_(i). If A_(ki)≠0, then there is a non-zero connection from active element E_(k) to active element E_(i). In any given embodiment the active elements may have all of the above properties, only one of the above properties, or any combination of the above properties. In an embodiment, different active elements may have different combinations of the above properties. Alternatively, all of the active elements may have the same combination of the above properties.

Examples of Specific Machine Architecture

Two examples of the many different types of possible machine architectures are a static machine and dynamic machine, which are described below in the next two sections.

Static Machine

In a static machine M(J, C, D), the properties of the active elements do not change over time. Although the active elements of a static machine are associated with functions of time (e.g., the input and output functions, the firing function, and the set of firing times), there are certain parameters that do not change with time. For example, in an embodiment in a static machine the connections (e.g., the message amplitudes, the message widths, and the transmission times) are not functions of time.

In a static machine the contents of sets J, C, and D do not change overtime. A user may be able to determine the times at which different active elements fire. A user may be able to set the properties of the static machine prior to using the static machine, but the properties of the static machine do not change while a program is running. In other embodiments, static machines may have other parameters that change over time.

Dynamic Machine

The active elements of a dynamic machine may have many of the same functions of time as a static machine, such as the input and output functions, the firing function, and the set of firing times. In a dynamic machine the connections (A_(ki)(s); ω_(ki)(s); τ_(ki)(S)) may be functions of time or of the firing times. In other words, each of the connection variables, A_(ki)(s), ω_(ki)(s), and τ_(ki)(s), is a function of s, which is a parameter for time. Thus, the message amplitudes, message widths and transmission times may change over time. In other embodiments other parameters may also be a function of time instead of, or in addition to, the connection parameters. The dependence of the connection parameters on time affects other parameters that depend on the connection variables. For example, in a dynamic machine, the set of recent firing times Ξ_(ki)(t) becomes Ξ_(ki)(t)={sεR: Effector k fired at time s and 0≦t−s−τ_(ki)(s)<ω_(ki)(S)}. Similarly, in an embodiment of a dynamic machine, the input functions become ${{\varnothing_{ki}(t)} = {\sum\limits_{s \in {\Xi_{ki}{(t)}}}{A_{ki}(s)}}},$ where {Ø_(ki)(t)}_(kεΓ∪Λ) is a collection of input functions. In other embodiments, dynamic machines may have other parameters that change over time.

EXAMPLE 1

FIG. 1A shows a system 100, which includes active elements B, X, Y, and Z. System 100 also include connections XB, YB, and ZB. Active element X is connected, via connection XB, to active element B. System 100 may be located within a machine, which may have many other active elements. Active element Y is connected, via connection YB, to active element B. Active element Z is connected, via connection ZB, to active element B. This example shows how the firings of active elements X, Y, and Z affect active element B. Active element X, fires at time t=4, active element Y fires at time t=1, and active element Z fires at t=2. The symbol A_(XB)=3 is the message amplitude from active element X to active element B. The message width from active element X to active element B is ω_(XB)=2. The transmission time from active element X to active element B is τ_(XB)=1. The transmission time τ_(XB) represents how long it takes for a message from active element X to arrive at active element B after active element X fires. These values are presented in the following table. Message Message Transmission Amplitude Width Time Firing A_(XB) ω_(XB) τ_(XB) Time From active element X 3 2 1 4 To To active element B

Similarly, the values below represent the message amplitude, message width and transmission time from active element Y to active element B. Also, included is the time that active element Y last fired. Message Message Transmission Amplitude Width Time Firing A_(YB) ω_(YB) τ_(YB) Time From active element Y 4 1 3 1 To To active element B

Similarly, the values below represent the message amplitude, message width and transmission time from active element Z to active element B. Also, included is the time that active element Z last fired. Message Message Transmission Amplitude Width Time Firing A_(ZB) ω_(ZB) τ_(ZB) Time From active element Z 4 2 2 2 To To active element B

FIGS. 1B-1I show a sequence of events associated with system 100. These figures are a convenient method for a person to understand the behavior of an active element. FIGS. 1B-1I correspond to times t=0 to t=7. In each of FIGS. 1B-1I there are four plots B, X, Y, and Z. Plots X, Y, and Z show the firing times of active elements X, Y, and Z and the times of arrival at active element B of the messages associated with connections XB, YB, and ZB, respectively. The differences between the firing times of active elements X, Y, and Z and the arrival times at active element B are the transmission times associated with connections XB, YB, and ZB.

Plot X shows the message from active element X on connection XB, and shows a firing time at t=4 and an arrival time at t=5. Plot Y shows the message from active element Y on connection YB, and shows a firing time at t=1 and an arrival time at t=4. Plot Z shows the message from active element Z on connection ZB, and shows a firing time at t=2 and an arrival time at t=4. Plot B shows the sum of the amplitudes of the messages that are arriving at active element B.

As shown in FIG. 1B, at time t=0, none of the active elements have fired, and consequently none of the plots X, Y, and Z show a message. Similarly, since no message has arrived at active element B, the amplitude arriving at active element B is shown as 0 in plot B.

As shown in FIG. 1C, at time t=1, active element Y fires, while active elements X and Z have not fired. Consequently, plot Y shows a message emerging from active element Y, and there are no messages shown on plots X and Z. Since the amplitude associated with connection YB is 4, message on plot Y has a height of 4. Although the message width associated with connection YB is 1, since the message is just beginning to emerge from active element Y, the message is shown as a line. Since no messages have arrived at active element B, the amplitude arriving at active element B is still shown as 0 in plot B.

As shown in FIG. 1D, at time t=2, zero units of time have passed since active element Z fired, one unit of time has passed since active element Y fired, and active element X has still not fired. Consequently, plot Y shows a message of width 1 emerging from active element Y, plot Z shows a message just beginning to emerge from active element Z, and no message is shown on plot X. Since the amplitude associated with connection ZB is 4, message on plot Z has a height of 4. The message shown on plot Y has now reached its full width, because the message width associated with connection YB is 1. Although the message width associated with connection ZB is 2, since the message is just beginning to emerge from active element Z, the message on shown plot Z is as a line. Since no messages have arrived at active element B, the amplitude arriving at active element B is still shown as 0 in plot B.

As shown in FIG. 1E, at time t=3, one unit of time has passed since active element Z began to fire, two units of time has passed since active element Y fired, and active element X has still not fired. Consequently, plot Y shows a message of width 1 displaced one unit of time from the firing time of active element Y, plot Z shows a message of width 1 that is still emerging from active element Z, and no message is shown on plot X. Although the message width associated with connection ZB is 2, since only one unit of time has passed since the message began to emerge from active element Z, the message shown plot Z is only one unit of time wide. Since no messages have arrived at active element B, the amplitude arriving at active element B is still shown as 0 in plot B.

As shown in FIG. 1F, at time t=4, two units of time has passed since active element Z fired, three units of time has passed since active element Y fired, and active element X fires. Consequently, plot Y shows a message of width 1 displaced three units of time from the firing time of active element Y, plot Z shows a message of width 2 emerging from active element Z, and a message at time 4 is shown on plot X. The message on plot Z has reached its full width. Although the message width associated with connection XB is 2, since the message just began to emerge from active element X, the message shown plot X is only a line. Since the amplitude of the message associated with connection XB is 3, the height of the message on plot X is shown as 3. The messages shown on plots Y and Z have just begun to arrive at active element B, and the amplitude of each is 4. Consequently, the sum of the amplitudes of the messages arriving at active element B is 8, as shown in plot B. If the threshold associated with active element B is less than 8, and if the refractory period is has passed, active element B will fire.

As shown in FIG. 1G, at time t=5, one unit of time has passed since active element X fired, three units of time has passed since active element Z began to fire, and four units of time has passed since active element Y began to fire. Consequently, plot Y shows a message of width 1 displaced four units of time from the firing time of active element Y, plot Z shows a message of width 2 displaced three units of time from the firing time of active element Z, and a message of width 1 emerging from active element X. Although the message width associated with connection XB is 2, since only one unit of time has passed since the message began to emerge from active element X, the message shown in plot X is only one unit of time wide. The message shown on plot Y is just finishing its arrival at active element B, the message shown on plot Z is still in the middle of arriving at active element B, and the message shown on plot X is just beginning to arrive at active element B. Consequently, the sum of the amplitudes of the messages arriving at active element B is now 11, as shown in plot B. If the threshold associated with active element B is less than 11, and if the refractory period has passed, active element B will fire. For example, in an embodiment, if the refractory period is 1, and the threshold is 6, then the active element will have fired twice, once at time t=4, when the sum of the amplitudes of the messages arriving at active element B was 8, and a second time at time t=5 when the sum of the amplitudes of the messages arriving at active element B is 11. Similarly, if the refractory period is 0.49, at time t=5, active element B will have fired 3 times: at time t=4, t=4.49, and t=4.98.

As shown in FIG. 1H, at time t=6, two units of time has passed since active element X fired, four units of time has passed since active element Z began to fire, and five units of time has passed since active element Y began to fire. Consequently, plot Y shows a message of width 1 displaced four units of time from the firing time of active element Y, plot Z shows a message of width 2 displaced two unit of time from the firing time of active element Z, and a message of width 2 emerging from active element X. The message width associated with connection XB is 2, and consequently, the message shown on plot X has reached its full width. The message shown on plot Z is just finishing arriving at active element B, and the message shown on plot X is also still in the middle of arriving at active element B. The message shown on plot Y is no longer arriving at active element B, and the amplitude of the message on connection YB (which is 4) is no longer added to the sum of amplitudes of messages arriving at active element B. Consequently, the sum of the amplitudes of the messages arriving at active element B is the sum of the amplitude of the messages associated with connections XB (which has a height of 3) and ZB (which has a height of 4), which sums to just 7, as shown in plot B. If the threshold associated with active element B is less than 7, and if the refractory period has passed, active element B will fire.

As shown in FIG. 1I, at time t=7, three units of time has passed since active element X fired, five units of time has passed since active element Z began to fire, and six units of time has passed since active element Y began to fire. Consequently, plot Y shows a message of width 1 displaced six units of time from the firing time of active element Y, plot Z shows a message of width 2 displaced five units of time from the firing time of active element Z, and a message of width 2 displaced three units of time from the firing time of active element X. The message shown on plot X is just finishing arriving at active element B. The messages shown on plots Y and Z are no longer arriving at active element B, and the amplitudes of the message on connection YB and ZB are no longer added to the sum of amplitudes of messages arriving at active element B. Consequently, the sum of the amplitudes of the messages arriving at active element B only includes the amplitude of the message associated with connection XB, and consequently the sum of messages arriving at active element B is 3. If the threshold associated with active element B is less than 3, and if the refractory period has passed, active element B will fire.

FIG. 1J shows a plot of the sum of amplitudes as a function of time, which corresponds to plot B of FIGS. 1B-I. At time t=4 the sum of amplitudes at active element B is 8, and remains at 8 until time t=5. At time t=5, the amplitude momentarily jumps to 11 and then declines to 7. The amplitude remains at 7 until time t=6. At time t=6, the amplitudes drops to 3, and remains at 3 until time t=7. At time t=7, the amplitude drops to zero. If the threshold of active element B is less than 3, then active element B may fire at anytime between time t=4 and t=7, depending on the value of the refractory period. If the threshold of active element B is greater than 3 and less than 7, then active element B may fire at anytime between time t=4 and t=6, depending on the value of the refractory period. If the threshold of active element B is greater than 7 and less than 8, then active element B may fire at anytime between time t=4 and t=5, depending on the value of the refractory period. If the threshold of active element B is greater than 8 and less than 11, then active element B may fire at time t=5, depending on the value of the refractory period.

EXAMPLE 2

Suppose an incoming message from active element E_(X) arrives at active element E_(B). Suppose active element E_(X) fires at time s=2. Suppose the transmission time τ_(XB) from active element E_(X) to active element E_(B) is given by τ_(XB)=5, and the message width ω_(XB)=2. Assume also that the current time is t=6.99. It follows that Ξ_(XB)(6.99)=ø, because t−s−τ_(XB)=6.99−2−5=−0.01 is not in the interval [0, ω_(XB)], and therefore |Ξ_(ki)(t)|=0. This is because the message from active element E_(X) has not yet arrived at active element E_(B). Therefore, based on the definition Φ_(XB)(6.99)=|85 _(ki)(6.99)|A_(XB), it follows that Φ_(XB)(6.99)=0, because |Ξ_(XB)(6.99)|=0.

However, at the time t=7, t−s−τ_(XB)=7−2−5=0, which is within the interval [0, ω_(XB)]. Consequently, Ξ_(XB)(7)={2}, because the value of Ξ_(XB)(7) is the set of firing times. Although Ξ_(XB)(7)={2}, the value of |Ξ_(XB)(7)| is given by |Ξ_(XB)(7)|=1 because |Ξ_(XB)(7)| is the number of elements in the set Ξ_(XB)(7). Assume that A_(XB)=2, then based on the formula Φ_(XB)(7)=|Ξ_(XB)(7)|A_(XB), it follows that, Φ_(XB)(7)=1, because t−s−τ_(XB) lies in the interval [0, ω_(XB)]. The calculation is t−s−τ_(XB)=7−2−5=0 and 0 lies in [0, 2]. Time t=7 is the time when the message from active element E_(X) first arrives at active element E_(B). Therefore, φ_(XB)(7)=|Ξ_(XB)(7)|A_(XB)=1·A_(XB)=A_(XB).

Next, it is shown how this message from active element E_(X) passes through active element E_(B). Assume that the firing time s is 2 and that the transmission time τ_(XB) is 5, at time t=9, t−s−τ_(XB)=9−2−5=2, which is the length of the message width, ω_(XB). In other words, time t=9 the message from active element E_(X) “exits” or “passes through” active element E_(B). Consequently, Ξ_(XB)(9)={2} because the firing time is 2, and t−s−τ_(XB) lies in the interval [0, ω_(XB)]. Since t−s−τ_(XB)=9−2−5=2, which lies in the interval [0, 2], therefore, Φ_(XB)(9)=A_(XB).

At, a small amount of time after the boundary condition t=9, for example at t=9.01 the function Ξ_(XB)(9.01)=ø, because t−s−τ_(XB) does not lie in the interval [0, ω_(XB)]. Specifically, the value of t−s−τ_(XB) is given by t−s−τ_(XB)=9.01−2−5=2.01, and 2.01 does not lie in [0, 2]. Therefore, Φ_(XB)(9.01)=0.

EXAMPLE 3

Suppose that two incoming messages from active element E_(X) and active element E_(Y) arrive at active element E_(B) at different times. Suppose active element E_(X) fires at s=2, the value of τ_(XB)=5 and the message width ω_(XB)=2. Assume that the message amplitude A_(XB)=4. Assume also that Active element E_(Y) fires at s=2. Assume that the transmission time from active element E_(Y) to E_(B) is τ_(YB)=7.5, and the message width ω_(YB)=2. The message amplitude from active element E_(Y) to E_(B) is A_(YB)=−2. The analysis of the input function Φ_(XB)(t) is performed in example 1, above. In that analysis, it was found that Φ_(XB)(t)=0 when t<7. Also, Φ_(XB)(t)=A_(XB)=4 when 7≦t≦9 and Φ_(XB)(t)=0 when t>9.

Using a similar analysis on Φ_(YB)(t), it is found that Φ_(YB)(t)=0 when t<9.5. Φ_(YB)(t)=A_(YB)=−2 when 9.5≦t≦11.5 and Φ_(YB)(t)=0 when t>11.5. Suppose the time that active element E_(B) last fired is t=2, so ψ_(B)(7)=2, because the value of ψ_(B)(7) is the time that the active element E_(B) last fired. Suppose the refractory period of active element E_(B) is r_(B)=4 and the threshold Φ_(B)=3.

To determine when active element E_(B) fires, g_(B)(t)=1 if Φ_(XB)(t)+Φ_(YB)(t)>θ_(B) and t≧ψ_(B)(t)+r_(B); otherwise, g_(B)(t)=0. Thus, g_(B)(t)=0 when t<7 because Φ_(XB)(t)+Φ_(YB)(t)=0+0<3. At time t=7, Φ_(XB)(7)+Φ_(YB)(7)=4+0>3. Also, the time last fired is ψ_(B)(7)=2, and the refractory period r_(B)=4, so t≧ψ_(B)(7)+r_(B)=2+4. Thus, g_(B)(7)=1. At time t=7.0001, the function ψ_(B) has the value ψ_(B)(7.0001)=7, and the refractory period is r_(B)=4, so t=7.0001<7+4. Thus, g_(B)(7.0001)=0. At time t=9, it follows that ψ_(B)(9)=7, and r_(B)=4 so t<ψ_(B)(t)+r_(B). Thus, g_(B)(9)=0. At time t=9.5, the sum of the input functions is given by Φ_(XB)(t)+Φ_(YB)(t)=0+−2<3. Thus, g_(B)(9.5)=0. At time t=11.5, the sum of the input functions is given by Φ_(XB)(t)+Φ_(YB)(t)=0+−2<3. Thus, g_(B)(11.5)=0. Overall, since g_(B)(7)=1, active element E_(B) fires once at time s=7.

Firing Representations

Consider active element E_(i)'s firing times F(E_(i))={s: g_(i)(s)=1}. If E_(i)'s refractory period is greater than zero, arrange the elements of the set F(E_(i)) into a sequence [s₀, s₁, s₂, . . . ], where s₀<s₁<s₂< . . . . Consider the interval of time W=[t₁, t₂], which starts at and includes time t₁, and ends at and includes time t₂. Let s_(m) be the smallest element lying in W, and s_(n) the largest element lying in W. Then E_(i)'s firing sequence within the window of computation W is F(E_(i);W)=[s_(m), s_(m+1), . . . , s_(n)], where s_(m)<s_(m)+1< . . . <s_(n−1)<s_(n) and $\underset{k = m}{\bigcup\limits^{n}}{\left\{ {s_{k} = {{s \in {W\text{:}\quad{g_{i}(s)}}} = 1}} \right\}.}$ In other words, the sequence of times [s_(m), s_(m+1), . . . , s_(n)] are the set of times within W for which g_(i)(s)=1 and active element E_(i) fired. The sequence F(E_(i);W) may be called a firing representation of the active element E_(i) over the interval of time W. With a collection of active elements {E₀,E₁,E₂, . . . }, one can create the infinite tuple (F(E₀,W), F(E₁,W), F(E₂,W), . . . ). The infinite tuple (F(E₀,W), F(E₁,W), F(E₂,W), . . . ) may be called a firing representation of the set of active elements {E₀,E₁,E₂, . . . } over the window of computation W. At a fundamental level of interpretation, firing representations may be used to express the input to, the computation of, and the output of a machine of active elements. At a more abstract level, the firing representations can be represented by an input symbol, an output symbol, a sequence of symbols, a number, or even a sequence of program instructions. Example of a Firing Representation

For each real number x within the interval [0, 1], one can construct a distinct firing representation of active elements {E₀,E₁,E₂, . . . } over a finite interval of time. For example, let γ>0 be a finite real number. Choose the interval of time for each active element to be [0, γ]. For any time t<0, there are no restrictions on when active elements E_(i) fired. With this in mind, for each index i, choose the refractor period r_(i)=γ and suppose the last time fired is ψ_(i)(0)=−γ, so that it is possible for active element E_(i) to fire or to not fire during the interval of time [0, γ]. Let the sequence (b₀, b₁, b₂, b₃ . . . ) be a binary representation of a real number x in [0, 1]. If b_(i)=1, then choose E_(i) to fire once during the interval of time [0, γ]. If b_(i)=0, then choose E_(i) to not fire during the interval of time [0, γ]. Thus a set of active elements can be used to represent a number, which shows the existence of a firing representation for x.

Sequence of Firing Representations

Let C={E₀,E₁,E₂, . . . } denote a collection of active elements. Also, let W₁,W₂,W₃, . . . ,W_(n) be a sequence of time intervals. Let F(C; W₁)=(F(E₀, W₁), F(E₁, W₁), F(E₂, W₁), . . . ) be a firing representation over the interval W₁. Let F(C; W₂)=(F(E₀, W₂), F(E₁, W₂), F(E₂, W₂), . . . ) be a firing representation of the active elements {E₀,E₁,E₂, . . . } over the interval of time W₂. In general, let F(C,W_(i))=(F(E₀, W_(i)); F(E₁, W_(i)); F(E₂, W_(i)), . . . ) be the firing representation over the interval of time W_(i). From these one can create a sequence of firing representations, F(C, W₁), F(C, W₂), F(C, W₃), . . . F(C; W_(n)).

Machine Computations

Let F(C, W₁), F(C, W₂), F(C, W₃), . . . F(C, W_(n)) denote a sequence of firing representations. Let F(C, S₁), F(C, S₂), F(C, S₃), . . . F(C; S_(n)) be a sequence of firing representations. If there exists a machine architecture for a machine (1) whose input elements can be represented with a sequence of firing representations F(C, S₁), F(C, S₂), F(C, S₃), . . . F(C; S_(n)), and (2) generates with its output elements the sequence of firing representations F(C, W₁), F(C, W₂), F(C, W₃), . . . F(C; W_(n)), then one says that the machine computes F(C, W₁), F(C, W₂), F(C, W₃), . . . F(C; W_(n)).

A Machine Represented by Firing Representation

A machine is an interpretation between two sequences of firing representations if the machine can compute the output sequence of firing representations from the input sequence of firing representations. When using a dynamic machine, it is possible to use a distinct machine architecture for each distinct sequence of firing representations.

A Static Program

Let M(J, C, D) denotes a machine, where M may be a static machine or a dynamic machine. Then a static program is a sequence of firing representations presented to M(J, E, D)'s input elements, J.

A Meta Program

A meta-program determines how to change a dynamic machine's architecture as it executes. In an embodiment, a meta program is executed in which the instructions of the meta program change the connections between the active elements in the computing machine. Let M(J, C, D) denote a dynamic machine. For each j, let the symbol x^(j) be used to represent a number, which may be any of A, ω, τ, representing a message amplitude, a message width or a transmission time, respectively.

In an embodiment, a meta-program may be represented by a finite sequence of quintuples [(x,¹,k₁, i₁,v₁ t₁); (x², k₂, i₂, v₂, t₂), . . . , (x^(n), k_(n), i_(n), v_(n), t_(n))] where each t_(i) represents a time and t_(i)<t₂< . . . <t_(n). In other words, the sequence of quintuples is arranged in time order. For each j, where 1≦j≦n, the quintuple, (x^(j),k_(j), i_(j),v_(j),t_(j)), instructs M(J,C,D) to assign the value v_(j) to connection element, x^(j) _(k) _(i) _(i) _(j) , at time t_(j). In particular, at time t₁, connection element, x¹ _(k) ₁ _(i) ₁ , is assigned the value v₁. If x¹ is the symbol A, then message amplitude A¹ _(k) ₁ _(i) ₁ , is assigned the value v₁, at time t₁. Similarly, at time t₂, connection element, x² _(k) ₂ _(i) ₂ , is assigned the value v₂. If x² is the symbol ω, then message width ω_(k) ₂ _(i) ₂ is assigned the value v₂ at time t₂. Changing the connections between active elements while executing a set of instructions, enables the active element machine to perform tasks that digital computers are unable to perform.

Example of Programming an Active Element Machine

A program for a machine may be represented as a set of pairs of numbers each pair including a time and an identification numbers identifying one of the active elements of a machine. Each pair of numbers specifies a time when a given active element should fire. An example of a simple static program is Machine Program Time Input element 0 0 5 0 11 0 The first line of this Static program has 0 in the time column and 0 in the input element column. The first line instructs that input element 0 to fire at time 0. The second line has a 5 in the time column and a 0 in the input element column. Thus, the second line instructs input element 0 to fire at time 5. The last instruction is on the third line, which instructs that input element 0 to fire at time 11. The above example of a program helps illustrate how a static program may be interpreted by a static machine. Longer more complex static programs can also be executed with machine.exe. The program may be run simultaneously with a meta program in a dynamic machine.

A program for a machine may be represented as a set of pairs of numbers each pair including a time and an identification numbers identifying one of the active elements of a machine. Each pair of numbers specifies a time when an output element fired and the identification number of the output element that fired. An example of output from a machine may be Machine Program Output Time Output element 3.00 0 4.00 0 5.00 0 6.00 0 7.00 0 8.00 0 9.00 0

The first line of this static program has a 3.00 in the time column and 0 in the output element column. The first line means that output element 0 fired at time 3.00. The second line of this output has a 4.00 in the time column and 0 in the output element column. The second line means that output element 0 fired at time 4.00. The rest of the lines in the above example are interpreted in a similar way.

In this embodiment, the output has the same format as the input file. Consequently, the output of one machine can be used as a static program for another machine. This enables one to compose the results of one or more machines. Using machine composition, a programmer can program a complex task with many small machines that perform simpler tasks. In an alternative embodiment, the input and output files may have different formats so that they are not confused with one another. In another embodiment, the programmer may have a choice whether the input and output programs have the same format.

Nand Function Example

It is well-known that any Boolean function or circuit can be constructed from a composition of one or more NAND functions, [Enderton]. The following table shows the definition of a NAND Boolean function, where |—the Sheffer stroke—represents the NAND binary operator. B C B|C 0 0 1 0 1 1 1 0 1 1 1 0

In this example, we use four active elements to build a circuit that computes the equivalent of a NAND function. Active elements B and C are the inputs; active elements H and L represent the output. When 0 is input into both B and C or when the input to one of active elements B and C is 1 and the input to the other of active elements B and C is 0, active element H fires and active element L does not fire, corresponding to the first three rows of the truth table for B|C=1. When the inputs to active elements B and C are both 1, active element L fires and active element H does not fire, corresponding to the last row of the truth table for B|C=0. With this correspondence in mind, the values in the following table represent the message amplitude, message width and transmission time from active element B to active element L. Message Message Transmission Amplitude Width Time A_(BL) ω_(BL) τ_(BL) From active element B 2 1 1 To active element L

Similarly, the values below represent the message amplitude, message width and transmission time from active element C to active element L. Message Message Transmission Amplitude Width Time A_(CL) ω_(CL) τ_(CL) From active element C 2 1 1 To active element L

Similarly, the values below represent the message amplitude, message width and transmission time from active element B to active element H. Message Message Transmission Amplitude Width Time A_(BH) ω_(BH) τ_(BH) From active element B −2 1 1 To active element H

Similarly, the values below represent the message amplitude, message width and transmission time from active element C to active element H. Message Message Transmission Amplitude Width Time A_(CH) ω_(CH) τ_(CH) From active element C −2 1 1 To active element H Set the refractory period of elements H and L to 2, in other words, r_(L)=r_(B)=2. Set the threshold of L to 3, in other words, θ_(L)=3. Set the threshold of H to −3, in other words, θ_(H)=−3. We assume the time last fired for effectors H and L is t=−1.

Finally, all four possible inputs are analyzed.

Case 1.) At time t=0, both active elements B and C, do not fire, corresponding to B|C=0|0. At time t=1, the refractory period of H and L has expired. At time t=1 the input to H is zero, so H fires because the input is greater than its threshold θ_(H)=−3. At time t=1 the input to L is zero, so L does not fires because the input is less than its threshold θ_(L)=3.

Case 2.) At time t=0, active element B fires and active element C does not fire, corresponding to B|C=0|1. At time t=1, the refractory period of H and L has expired and the pulse from B has arrived. At time t=1, the input to H is −2 because A_(BH) =−2. Thus, H fires because its input is greater than its threshold θ_(H)=−3. At time t=1, the input to L is 2 because A_(BL)=2. Thus, L does not fire because its input is less than its threshold θ_(L)=3.

Case 3.) At time t=0, active element B does not fire and active element C fires, corresponding to B|C=1|0. At time t=1, the refractory period of H and L has expired and the pulse from C has arrived. At time t=1, the input to H is −2 because A_(CH)=−2. Thus, H fires because its input is greater than its threshold θ_(H)=−3. At time t=1, the input to L is 2 because A_(CL)=2. Thus, L does not fire because its input is less than its threshold θ_(L)=3.

Case 4.) At time t=0, active element B fires and active element C fires, corresponding to B|C=1|1. At time t=1, the refractory period of H and L has expired and the pulses from B and C have arrived. At time t=1, the input to H is −4 because A_(BH)+A_(CH)=−4. Thus, active element H does not fire because its input is less than its threshold θ_(H)=−3. At time t=1, the input to L is 4 because A_(BL)+A_(CL)=4. Thus, active element L fires because its input is greater than its threshold θ_(L)=3.

In summary, an AND operation is obtained by having an output active element, which in the above example is active element L, that does not fire unless the sum of inputs of two input active elements, which in the above example are active elements B and C, is greater than a set threshold. The negation of the digital operation AND, called NAND, may be obtained by changing the signs of both the amplitudes and the threshold, without changing the other parameters. A NAND operation in the above example may be represented by active element H, or it may represented by the collective behavior of both H and L.

Input and Output Interpreter

There are at least two different methods of programming a machine. In the first method, called explicit programming, someone explicitly designs a machine architecture, and writes a static program or meta program. The design of a machine architecture and a program, using explicit programming, were explained above. Despite the fact that machine instructions for a machine of active elements may be quite different from a digital computer's machine instructions, explicit programming is analogous to writing a computer program in assembly language, C, or some other programming language for a digital computer.

A second method, called implicit programming, designs the architecture and programs of a machine based on the desired machine behavior. A method for implicit programming is presented in the next section.

In both explicit programming and implicit programming, the use of an Input Interpreter and Output Interpreter may simplify the programming task. In any programming endeavor, the task that needs to be solved, performed, or finished can be represented mathematically by an (input, output) set of pairs, {(I₁,O₁), (I₂,O₂), . . . }. In some cases, the set, {(I₁,O₁), (I₂,O₂), . . . (I_(n),O_(n))}, is finite. In other cases, it can be infinite. For each i, I_(i) is the input point, and O_(i) is the corresponding output point. The (input, output) set specifies the behavior of the machine that is to be designed. An input and output interpreter translates a chosen pair (I_(i),O_(i)) to the native machine instructions of the machine. Specifically, the input interpreter translates the point I_(i), into a sequence of firing activities executed by the input active elements, J. The output interpreter translates the firing activity of the output active elements, D, into an output point, O_(i). This output point represents the output of the machine. For example, the input points may represent hand written letters of the alphabet, and the output points may represent an identification of the letter.

An input interpreter and output interpreter may be designed with C++ source code and can change, depending on what the machine is designed to do. Also, an input interpreter can be implemented as a distinct machine. Likewise, an output interpreter can be implemented as a distinct machine. Alternatively the same machine may be used as both the input and output interpreter or the machine performing the computations may perform its own input and/or output interpretation.

Evolutionary Design of an Active Element Machine

Implicit programming on an active element machine can be accomplished using evolutionary methods. Evolutionary methods for extremely different applications were first introduced by [Box], [Bledsoe], [Bremermann], and [Friedman]. Implicit programming is preferable to explicit programming when the programmer knows what she wants the active element machine to accomplish, but she does not know how to explicitly design the active element machine architecture, static program or meta program. This is analogous to a CEO of a company asking her engineers to build a new computer, but she does not know how to build this computer. The CEO knows how she wants the computer to behave, but does not know how to explicitly build it.

The symbol Θ represents an optimal fitness value. As an example, a fitness value may be the percentage of input/output pairs correctly computed, called the computing accuracy. In some applications, computing speed and the number of active elements used, may be important, so the fitness value may be a weighted average of the speed, number of active elements, and computing accuracy. For example, the weighting may be 40% computing accuracy, 30% speed and 30% number of elements. In other words, if a machine has a fitness value greater than Θ, then it can competently compute the (input, output) set of pairs, {(I₁,O₁), (I₂,O₂), . . . }. The fitness of M_(j) is determined by its overall ability to represent, O_(i), with its output active elements, after M_(j)'s input active elements receive input I_(i). The fitness may also dependent on the amount of memory M_(j) consumes, the average amount of computational time that it takes to compute the outputs M_(j), and/or the amount of other resources consumed by M_(j). A smaller amount of memory, computational time, and/or other resources consume increases the fitness.

Directed Graph

A machine may be represented by a directed graph in which the vertices represent active elements, and the lines connecting the vertices (referred to as edges) indicate which active elements are capable of sending messages to which other active elements.

FIG. 2 shows two directed graphs. In a directed graph diagram, a dot represents a vertex. A line segment with one arrow pointing from one vertex to the other vertex represents a directed edge. Plot 202 of FIG. 2 is a graph that contains a cycle. A cycle is formed when it is possible to follow the line segments in the direction of the arrows back to the starting point. Plot 204 is another directed graph that does not contain a cycle so it is called a tree.

A useful analogy is that the structure of hyperlinks on the World Wide Web is a directed graph because it is possible to click on a link to go to web page A, by clicklng on a link while at web page B, but not vice versa. In mathematical language, a line segment connected from B pointing to A may be written as (B,A), which is called an edge in the directed graph. However, in this example (A,B) is NOT an edge, because the line connecting A and B points to A and does not point to B.

Let V={v₁, v₂, . . . , v_(n)} be a finite set of n vertices. An edge in a directed graph is an ordered pair (v₁, v_(j)) with each vertex lying in V. Let E={(v_(i1), V_(k1)), (v_(i2), V_(k2)), . . . , (v_(im), V_(km))} be a finite set of edges. A directed graph is formally, G=(V,E), where E and V have just been defined. A machine including active elements can be represented by a directed graph. Each edge may represent a connection between two active elements (which are represented by the vertices).

Cyclic Graph Evolution

There are many methods of improving the fitness of a machine, which include deterministic and probabilistic methods. An advantage of using a probabilistic method is the search for an improved machine extends over a larger space. Probabilistic methods are less likely to improperly identify a local extremum (a minimum or maximum) as a global extremum, and can therefore obtain often obtain better fitnesses. On example of a method of improving the fitness is Cyclic Graph Evolution, which will be abbreviated with the letters, CGE. CGE may be performed in any of a number of ways. In one embodiment, CGE may be used to design at least one machine that competently computes the collection of (input, output) pairs, {(I₁,O₁), (I₂,O₂), . . . (I_(n),O_(n))}. In an embodiment, first an initial generation of machines, A={M_(O),M₁,M₂, . . . M_(m)} is built. In an embodiment, the number m represents the number of machines in each generation of the evolutionary process. In other words, the evolutionary process may involve the construction of a set of m machines. Each of the machines is varied in order to find a machine with an adequate fitness. There are many possible methods of varying the machines.

In one embodiment, two methods of varying machines are used, which are permutation and mutation. During permutation, one or mores sets of one or more components (e.g., active elements) of one machine are switched with other components. In one type of permutation, which will be referred to as a crossover, the components are switched with one more components of another machine. Permutations, such as crossovers increase the complexity and variety of machines searched when looking for a machine with a better fitness. During a permutation, one or more parameters are altered without there necessarily being any relationship to parameters altered in another machine. For example, the value of any one of, or any combination of, an amplitude, message width, transmission time, threshold, and/or refractory period may be changed. In an embodiment, an active element and/or connection may be added or removed. In different embodiments different sets of these parameters may be varied during a mutation or permutation.

In an embodiment, after constructing a set of machines, the fitness of each machine, M_(j) is determined. Then the following is performed multiple times: CGE randomly chooses two machines for possible crossover and mutation, from the current generation based on their fitness. As an example, if one machine, M₁, has a fitness of 74% and another machine, M₂, has a fitness of 90%, then M₂ is more likely to be chosen for the next generation. However, since the machines are chosen randomly, it is still possible for M₁ to be chosen for the next generation, but not M₂. Sometimes the two machines selected are crossed over and/or mutated. The choice of whether to perform a mutation, and/or whether to perform a mutation may be made randomly. For example these choices may based on a random number selection. After a possible crossover and mutation, these two machines are placed in the next generation. The selection of two machines, and possible crossover and mutation is repeated until the next generation has m machines. CGE is repeated until the best machine M_(best) has a fitness greater than Θ. The CGE design process is presented below as an algorithm.

An Example of an Algorithm for Performing CGE to Design an Active Element Machine

An example of psuedocode for designing machines via CGE is as follows. Build an initial population of machines, A={M₀, M₁, M₂, . . . M_(m)}. while(true) {   Set G equal to the empty set. (G stores the machines in the next   generation.)   For each j in {1, 2, 3,...,m}   {     For each i in {1, 2, 3,...,n}     Find M_(j)'s overall ability to represent, O_(i), with its output active       elements, after M_(j)'s input active elements receive input I_(i).     Store this ability as the fitness of M_(j) .   }   Set q equal to the number of machines with fitness greater than Θ.   If q ≧ 1, exit the loop while(true) and return M_(best), the machine with     the highest fitness.   while( the size of G < m)   {     Randomly choose two machines, M_(j) , M_(k), from A for the next     generation.     (The probability of choosing M_(j) is proportional to its fitness.)     Randomly choose a number r between 0 and 1.     If r < p_(crossover), then crossover machines M_(j) and M_(k).     Randomly choose numbers s₁ ; s₂ between 0 and 1.     If s₁ < p_(mutation), then mutate machine M_(j) .     If s₂ < p_(mutation), then mutate machine M_(k).     Set G equal to G U {M_(j) , M_(k)}.   }   Set A equal to G. }

In the above program, the symbol P_(crossover) denotes the probability that two machines chosen for the next generation will be crossed over (e.g., have modules interchanged). Also, the symbol P_(mutation) denotes the probability that a machine will be mutated (e.g., have a change made to one of the machines parameters). In an embodiment, the parameters P_(crossover), P_(mutation), and m are input by a user at the start of running the CGE. In an embodiment, if a set of mutations and crossovers for a given machine do not result in a machine with the same fitness or a higher fitness than the initial fitness, then the mutation is not performed. Optionally, a different set of mutations and crossovers are chosen. In an embodiment, after making each mutation or crossover, a determination is made as to what fitness results, and if the fitness is lower the mutation or crossover is not made. Optionally, if the fitness is lower a different mutation or crossover is performed. Optionally, a random number may be chosen to see if another mutation or crossover is performed.

Constructing an Initial Set of Machines

FIG. 3 shows an example of a machine in which the active elements are divided into modules to facilitate cyclic graph evolution, which is an example of some further details of the construction of the machines in the initial population. Each machine may be constructed separately. Each machine that is designed by cyclic graph evolution may be composed of an Input Module, an Output Module, and one or more Internal Modules, such as m₁, m₂, m₃, . . . m_(K), as illustrated in FIG. 3. In an embodiment, every active element lies in exactly one module. The manner in which the active elements are organized into modules does not affect how the machine computes. However, as explained below, the manner in which the active elements are organized into modules may affect how two machines are created for CGE, crossed over, and mutated. A non-zero connection between two active elements lying in two distinct modules is called an external connection. A non-zero connection between two active elements lying in the same module is called an internal connection.

For each machine created, an Input Module and an Output Module are created. Further, a random number k may be chosen such that MIN_MODULES_PER_MACHINE≦k≦MAX_MODULES_PER_MACHINE, and k internal modules are created. In other embodiments, the initial number of internal modules in a machine may be chosen in a different manner. For example, in an embodiment the number of initial internal modules may be chosen based on the number of computations that are expected to be required to perform a desired task. In another embodiment, the number of internal modules chosen may be a fixed number.

Each module is constructed separately. External connections are added afterwards. For each module, a random number u may be chosen such that MIN_ACTIVE_ELEMENTS_PER_MODULE≦u≦MAX_ACTIVE_ELEMENTS_PER_MODULE. Next, u active elements are created. In other embodiments, the initial number of active elements in a module may be chosen in a different manner. For example, in an embodiment the number of initial active elements may be chosen based on the number of computations that are expected to be required to perform a desired task. In another embodiment, the number of active elements chosen may be a fixed number for a given machine or a fixed number for all machines. In another embodiment, there may be a fixed set of numbers in which each number represents the initial number of active elements in a module within a given initial machine.

For each active element, the refractory period may be randomly chosen between MIN_REFRACTORY_PERIOD and MAX_REFRACTORY_PERIOD. For each active element, the threshold may be randomly chosen between MIN_THRESHOLD and MAX_THRESHOLD. In other embodiments, the initial thresholds may be chosen in a different manner. For example, in an embodiment the value of an initial threshold may be chosen based on the number of initial input connections and/or type of computations that are expected to be required to perform a desired task. In another embodiment, the value of the initial thresholds may be chosen to be a fixed number. In an embodiment, the value of the initial thresholds may be chosen to be the same number for an entire module, for an entire machine and/or for all machines. In another embodiment, there may be a fixed set of thresholds in which each threshold represents the initial threshold of a given active element.

Next, for each active element, a random number v is chosen such that MINIMUM_CONNECTIONS≦v≦MAXIMUM_CONNECTIONS. This means that v connections are created for this particular active element. In other embodiments, the initial connections may be chosen in a different manner. For example, in an embodiment the number of initial connections may be chosen based on the number and/or type of computations that are expected to be required to perform a desired task. In another embodiment, the number of connections chosen may be a fixed number. In an embodiment, the number of the initial connections may be chosen to be the same number for an entire module, for an entire machine and/or for all machines. In another embodiment, there may be a fixed set of numbers in which each number represents the initial number of connections to a given active element.

For each of these v connections, the initial value of the message amplitude may be randomly chosen between MIN_AMPLITUDE and MAX_AMPLITUDE, inclusive. For each connection, the value of the message width is randomly chosen between MIN_MESSAGE_WIDTH and MAX_MESSAGE_WIDTH, inclusive. In other embodiments, the message widths may be chosen in a different manner. For example, in an embodiment the message widths may be chosen to have a fixed initial value. In an embodiment, all of the initial message widths may be chosen to be the same. In an embodiment, the value of the initial message widths may be chosen to be the same number for an entire module, for an entire machine and/or for all machines. In another embodiment, there may be a fixed set of numbers in which each number represents the initial message width of a given active element.

For each connection, the initial transmission time is randomly chosen between MIN_TRANSMISSION_TIME and MAX_TRANSMISSION_TIME, inclusive. In other embodiments, the initial transmission times may be chosen in a different manner. For example, in an embodiment the transmission time may be chosen to have fixed set of initial values. In an embodiment, all of the initial transmission times within a given module or machine may be chosen to be the same.

An Example of a Crossover

FIG. 4 shows an example of how CGE executes a crossover between two machines, machine A and machine B. The variable n_(n), represents the number of internal modules in the machine A, and the variable n2 represents the number of internal modules in machine B. For machine A, a random whole number j₁ is chosen, lying between LOWER_FRACTION_NUM_MODULES*n₁ and UPPER_FRACTION_NUM_MODULES* n₁. For machine B, a random whole number j₂ is chosen, lying between LOWER_FRACTION_NUM_MODULES * n₂ and UPPER_FRACTION_NUM_MODULES * n₂. In FIG. 4, for machine A, j₁=2 was selected. For machine B, j₂ =1 was selected. Since j₁=2, two distinct numbers are chosen randomly from the set {1, 2, . . . , n₁}. In the example of FIG. 4, for machine A, these two numbers were chosen as 2 and 3. Since j₂=1, one number is randomly chosen from {1, 2, . . . , n₂}. In the example of FIG. 4, the number 2 was chosen. Based on the above choices, internal modules m₂ and m₃ of Machine A are crossed over (e.g., switched) with internal module m₂ of Machine B. All the external connections to these modules are also severed.

In FIG. 4, after the crossover, new external connections are created and added to the internal modules that were crossed over. In an embodiment, internal connections in a module that is crossed over are not changed or severed as part of the crossover. In another embodiment, internal connections may be altered after and/or during the crossover.

More About Mutations

This part further discusses mutations of a Machine. There are multiple ways to mutate a machine. An active element can be added to a module along with some non-zero connections, connecting the new active elements to active elements inside the same module, and possibly connecting the active element to active elements in different modules. A second type of mutation deletes an active element. Any non-zero connections are removed that connect to the active elements being deleted. A third type of mutation may change the message amplitude, message width, and/or the transmission time of a connection. Similar to adding an active element, a fourth type of mutation adds a new connection to an active element. Similar to removing an active element, a fifth type of mutation removes a connection from a machine.

A sixth type of mutation creates a new module containing new active elements and connections between them and connects this new module to other modules with new external connections. A seventh type of mutation deletes a module and removes all of the deleted module's external connections.

In one embodiment, P_(crossover) should usually range from 0.3 to 0.7. Also, in one embodiment P_(mutation) should usually be less than 0.1. In other embodiments, P_(crossover) and/or P_(mutation) may have other values. Previous evolutionary methods evolve directed graphs that contain no cycles. CGE is the first evolutionary method to evolve directed graphs containing cycles. Including cycles in the directed graph of a machine may facilitate the performance of tasks that require the use of an iterative process. It is also the first evolutionary method that is capable of performing crossovers and mutations on these directed graphs containing cycles.

In previous evolutionary methods, each vertex represents a static function. The directed edge represents output from one function delivered as input to the other function. Because of this structure, information does not flow in the opposite direction. Furthermore in a function, the output cannot be computed until it receives the input. Consequently, information flows in a synchronized way. On the other hand, the objects that CGE operates on (e.g., the active elements) are entirely different. Active elements may have more structure, more flexibility, and more computing capability than functions. Each vertex may represent one active element, and each directed edge may represent a non-zero connection between active elements. Furthermore, it is also possible to have a non-zero connection between two active elements, so information may flow asynchronously in both directions. Since active elements can change over time, active elements can mimic the behavior of an infinite number of functions.

Designing a VLSI

CGE can be used to design analog VLSI circuits which are suitable for implementing machines in hardware. One of Mead's primary methods of designing subthreshold analog circuits, [MEAD], is to use piecewise linear analysis to design non-linear circuits. Piecewise linear analysis becomes difficult as the size of the circuit increases. Also, piecewise linear analysis often requires a person to come up with clever techniques for predicting how the nonlinear circuit will behave. In other words, it is very difficult to write a computer program that can automate the design of circuits representing machines, using piecewise linear analysis; it also may increase the time and financial cost of designing machines. CGE does not require cleverness. One can treat the analog VLSI circuit as a black box. Only a set of inputs {I₁, I₂, . . . I_(n)} and a corresponding set of outputs {O₁,O₂, . . . ,O_(n)}, are required of the analog VLSI circuit. Then execute CGE on the (input, output) set, {(I₁,O₁), (I₂,O₂), (I₃,O₃), . . . }. The machine that results from the execution of CGE can be used as the VLSI circuit desired.

Hardware Implementation of Active Elements

This section addresses the implementation of a machine in hardware; an example is a semiconductor chip. In a hardware implementation of a machine, computation still can be robustly executed even though there may be a small amount of variance in the transmission time or the exact time an active element is supposed to fire. The analysis below explains how to design an active element machine despite substantial variance in the physical parameters of the hardware.

Let r denote the refractory period of an active element. Let t_(detect) denote the time at which active element E_(i) detects that some other active element has fired. Let t_(actual) denote the actual time that this other active element fired. To simplify the analysis, ignore the transmission time from the active element that fired to the active element that received the message fired. Let ε_(i) denote the maximum possible value for |t_(detect)−t_(actual)| in active element E_(i). Define ε=max{ε_(i): E_(i) is an active element in machine M}. If ε_(i)=0, then all active elements detect when another active element has fired with perfect precision. Let T denote a finite interval of time such that the hardware obeys 0<ε<r <T.

FIG. 5 shows error tolerance of an embodiment of an active element. Define χ: $\left. {N \times N}\rightarrow{N\quad{as}\quad{\chi\left( {L;n} \right)}} \right. = {{L*\left( {L - 2} \right)*\left( {L - 4} \right)\ldots*\left( {L - {2n} + 2} \right)} = {\prod\limits_{k = 1}^{n}\quad{\left( {L - {2k} + 2} \right).}}}$ As an example, χ(7, 3)=7*5*3. As another example, χ(20, 5)=20*18*16*14*12. Choose T so that r divides T with zero remainder.

In this example, the formula: $\sum\limits_{n = 1}^{\frac{T}{r}}\frac{{\chi\left( {\frac{T}{r},n} \right)}\left( \frac{r}{ɛ} \right)^{n}}{n!}$ is the maximum number of possible distinct firing configurations for an active element, during the interval of time T. This number of firing configurations determines the number of different states that the active element could be in during this time period.

FIG. 6 shows a schematic diagram of an embodiment of a circuit of an active element. The computing machine, which may be referred to as an Active element machine, can be implemented in hardware and built from a variety of different components. For example, the computing machine may be built from circuits of transistors that operate subthreshold. FIG. 6 illustrates how transistors operating at subthreshold can be used to implement an active element.

In FIG. 6, transistors are denoted with the symbol T; capacitors are denoted with the symbol C; the voltage at a particular location is denoted with the symbol V; and the current is denoted with the symbol I and an adjacent arrow. The subscripts help further describe or distinguish components.

Regarding the firing of the active element, in FIG. 6, the four transistors, T₃, T₄, T₅, and T₆, act collectively as an amplifier. The characteristics of this amplification are shown in FIG. 7. Capacitor C₁ is connected between ground and an input terminal. The gates of transistors T₃ and T₄ are electrically connected to the input terminal. Transistors T₃ and T₄ are connected drain to drain to one another, where a line is electrically connected to the gates of transistors T₅ and T₆. Transistors T₅ and T₆ are also connected drain to drain to one another, and the drain-drain connection is electrically connected to an output terminal. Transistors T₃ and T₅ are p-channel FETs, and have their sources connected to a positive voltage source and possibly a load, as indicated by the diagonal lines at the end of top of the lines feeding into the drains of transistors T₃ and T₅. Transistors T₄ and T₆ are n-channel FETs and have their sources connected to ground. The drains of transistors T₅ and T₆ are electrically connected to the output terminal and are also electrically connected to one end of a capacitor C₂. The other end of the capacitor C₂ is electrically connected to the gates of transistors T₃ and T₄. In an alternative embodiment, the voltage source is a negative voltage source, and transistors T₃ and T₅ are n-channel transistors having their sources connected to the sources of p-channel transistors T₄ and T₆.

Transistor T₁ has its drain electrically connected to the input terminal, one end of capacitor C₁ and the gates of transistors T₃ and T₄. Transistor T₁, has its gate electrically connected to the output terminal, to one end of capacitor C₂, and to the drain-drain connection of transistors T₅ and T₆. Transistor T₂ has its drain electrically connected to the source of transistor T₁, its gate electrically connected to an adjustable voltage source, labeled V₂, and its source connected to ground.

As indicated by the circles at the gates of transistors T₃ and T₅, transistors T₃ and T₅ are doped in a manner such that is the gate current is biased in the opposite direction as that of transistors T₄ and T₆ (e.g., if transistors T₃ and T₅, are n-channel FETs, then transistors T₄ and T₆ are p-channel FETs). Transistors T₃ and T₅ amplify one of the positive or negative part of the signal, while transistors T₄ and T₆ amplify the other part of the positive or negative part of the signal. As transistors T₃, T₄, T₅, and T₆ form an amplifier, and it is possible to form an amplifier even with just one transistor, whether or not all four transistors are used is optional.

Additionally, transistors T₃ and T₄ form a first stage of the amplifier, which inverts the polarity of the signal, while transistors T₅, and T₆ form a second stage of the amplifier, which inverts the polarity of the signal to its original polarity. By including two stages of amplification, the rise in voltage is also sharper than were there only one stage of amplification. The second stage of amplification inverts the signal without loosing signal strength.

Before the firing takes place, the initial voltage of the node, denoted as V_(in) in FIG. 6, is low. As V_(in) increases, the output voltage V_(out) increases. As V_(out) increases, V_(out) pushes back through capacitor C₂, which causes V_(in) to increase, which then causes V_(out) to increase faster. Once this positive feedback loop starts, V_(out) abruptly increases to V_(max). The abrupt increase in V_(out) from a low voltage (near or at ground) to a high voltage (near or at V_(max)), is a physical representation of the active element firing. In alternative embodiments, other types of positive feedback may be used instead of a capacitor C₂.

After the active element has fired, the voltage V_(out) may be decreased rapidly so that a pulse is created. One way to create the end of the pulse, is to enable the charge on C₂ to drain away when the output, V_(out) is high, via transistors T₁, and T₂. In particular, transistor T₂ helps determine the pulse width. Once, V_(out), is high, the gate of transistor T₁ is pulled to its high setting, which opens the channel of transistor T₁. As a result, the current I_(r) flows from the capacitor C₁ to ground lowering V_(out). Transistors T₁ and T₂ may be n-channel or p-channel FETs depending upon whether voltage V_(out) is negative or positive or may be other types of transistors. The threshold depends to at least some degree upon the capacitance of capacitors C₁ and C₂. If the capacitance of C₁ is increased then it takes more charge on C₁ for V_(in) to reach the threshold voltage V_(L). Referring to FIG. 7, if the voltage, denoted as V₂, on the gate of transistor T₂ is increased, then charge drains off the capacitor C₁ faster. Consequently, this decreases V_(in) at a faster rate, so biasing the gate of transistor T₂ turns off the active element faster, and the bias on T₂ may be used to control the pulse width. Alternatively, another method of varying the pulse width may be used, such as by including a variable delay in the connection from V_(out) to T₁.

Using transistors operating at subthreshold reduces the amount of power consumed by more than 5 orders of magnitude when compared to using transistors operating at or above threshold. In Carver Mead's words, for a transistor to operate subthreshold means: “The gate voltage at which the mobile charge [in the transistor] begins to limit the flow of current is called the threshold voltage . . . . Most circuits described in this book operate in subthreshold—their gate voltages are well below the threshold voltage,” [MEAD]. Furthermore, when transistors operate subthreshold, the amount of heat produced is greatly reduced when compared to operating at or above threshold.

A machine of active elements may be implemented on a digital computer. However, the active element machine realizes far greater computational power when its machine instructions are directly implemented in suitable hardware. A good hardware implementation may enable the active element machine to execute computations more than four orders of magnitude faster than today's digital computers.

Other Extensions

Although the invention has been described with reference to specific embodiments, it will be understood by those skilled in the art that various changes may be made and equivalents may be substituted for elements thereof without departing from the true spirit and scope of the invention. In addition, modifications may be made without departing from the essential teachings of the invention. 

1. A system comprising: a multiplicity of computing elements; and a multiplicity of couplings communicatively connecting the multiplicity of computing elements to one another, such that the couplings are capable of transmitting messages between the multiplicity of computing elements.
 2. The system of claim 1, wherein a first portion of the multiplicity of computing elements, which will be referred to as input elements, are capable of receiving input for the system; and a second portion of the multiplicity of computing elements, which will be referred to as output elements, each have a content that represents output of the system.
 3. The system of claim 2, wherein the input elements are capable of being configured to send at least one message of the messages to others of the input elements.
 4. The system of claim 2, wherein a third portion of the multiplicity of computing elements, which will be referred to as computational elements, are capable of receiving at least a first message of the messages from the input elements, and sending at least a second message of the messages to the output elements.
 5. The system of claim 4, wherein the computational elements are capable of sending at least the second message to at least one other of the computational elements.
 6. The system of claim 1, wherein at least one computing element of the multiplicity of computing elements is associated with a period of time that must elapse after sending a first message prior to sending a second message, wherein the period of time that must elapse must be greater than zero, and will be referred to as a refractory period.
 7. The system of claim 1, wherein at least one message of the messages is associated with an amplitude that is dependent on a first of the multiplicity of computing elements that is sending the at least one message and on a second of the multiplicity of computing elements of the computing elements that is receiving the at least one message.
 8. The system of claim 7, wherein the system is configured such that the amplitude can be changed as a function of time while executing a sequence of instructions.
 9. The system of claim 1, wherein at least one message of the messages is associated with a width that is dependent on a first of the multiplicity of computing elements that is sending the at least one message and a second of the multiplicity of computing elements that is receiving the at least one message.
 10. The system of claim 9, wherein the system is configured such that the width can be changed as a function of time while executing a sequence of instructions.
 11. The system of claim 1, wherein at least one message of the messages is associated with a transmission time that is dependent on a first of the multiplicity of computing elements that is sending the at least one message and a second of the multiplicity of computing elements that is receiving the at least one message.
 12. The system of claim 11, wherein the system is configured such that the transmission time can be changed as a function of time while executing a sequence of instructions.
 13. The system of claim 1, wherein at least two computing elements of the multiplicity of computing elements are associated with a period of time during which if a combination of amplitudes of received messages is greater than a threshold, a computing element of the at least two computing elements sends a message, wherein the received messages are those of the messages that were received from the at least two computing elements.
 14. The system of claim 13, wherein said combination is a sum.
 15. The system of claim 13, wherein said combination is a product.
 16. The system of claim 13, wherein said combination is a convolution.
 17. The system of claim 13, wherein at least one message of the messages is associated with a width, which is a length of time associated with the at least one message, that is dependent on a first of the multiplicity of computing elements that is sending the at least one message and a second of the multiplicity of computing elements that is receiving the at least one message; at least one computing element of the multiplicity of computing element is associated with a duration of time that must elapse after the at least one computing element last fired, wherein the duration of time that must elapse must be greater than zero, and will be referred to as a refractory period; and the period of time starts after the refractory period.
 18. The system of claim 1, wherein at least one computing element of the multiplicity of computing elements is associated with a time during which if a combination of amplitudes of messages received from other computing elements is less than a threshold, the at least one computing element sends a message.
 19. The system of claim 18 wherein said combination is a sum.
 20. The system of claim 18 wherein said combination is a convolution.
 21. The system of claim 1, wherein at least one computing element of the multiplicity of computing elements is associated with a time during which if a combination of amplitudes of messages received from other computing elements is inside the range of a lower threshold and upper threshold, the at least one computing element sends a message.
 22. The system of claim 21, wherein said combination is a sum.
 23. The system of claim 1, wherein at least one computing element of the multiplicity of computing elements is associated with a time during which if a combination of amplitudes of messages received from other computing elements is outside the range of a lower threshold and upper threshold, the computing element sends a message.
 24. The system of claim 23, wherein said combination is a sum.
 25. The system of claim 1, wherein each computing element of at least a group of the multiplicity of computing elements is associated with a condition that causes the computing element to fire, and a time at which the computing element fires will be denoted as a firing time, and the system is configured to represent a symbol as a sequence of firing times.
 26. The system of claim 1, wherein each computing element of at least a group of the multiplicity of computing elements is associated with a condition that causes the computing element to fire, and a time at which the computing element fires will be denoted as a firing time, and the system is configured to represent a sequence of one or more instructions as a sequence of one or more firing times.
 27. The system of claim 1, wherein at least one message of the messages is associated with an amplitude that is dependent on a sending computing element, which is a computing element of the multiplicity of computing elements that is sending the at least one message, and a receiving computing element, which is a computing element of the multiplicity of computing elements that is receiving the at least one message; the system is configured such that the amplitude can be changed as a function of time while executing a sequence of instructions; the at least one message is associated with a width that is dependent on the sending computing element and the receiving computing elements; the system is configured such that the width can be changed as a function of time while executing a sequence of instructions; the at least one message is associated with a transmission time that is dependent on the sending computing element and the receiving computing element; the system is configured such that the transmission time can be changed as a function of time while executing a sequence of instructions; and the system is configured for executing a sequence of instructions in which each instruction specifies a computing element, a value, and a time at which to assign the value, and a designation of whether to assign the value to the amplitude, the width, or the transmission time.
 28. A method comprising: causing the system of claim 1 to execute a series of instructions in which each instruction is at least a designation of a pair of communicatively coupled computing elements, a value, a time when to apply the value, and a designation as to whether the value is to be applied to a width, amplitude, or transmission time associated with a message sent between the pair of communicatively coupled computing elements.
 29. A method of programming the system of claim 1 comprising: configuring the system to produce a set of outputs in which each output of the set corresponds to a given input of a set of inputs.
 30. A method of programming the system of claim 1 comprising: choosing a set of instructions to produce a set of outputs in which each output of the set of outputs corresponds to a given input of a set of inputs.
 31. A method comprising: causing a plurality of elements to send and receive messages, wherein the messages travel along communication lines, and wherein each communication line connects a pair of elements from the plurality of elements.
 32. The method of claim 31, further comprising: adjusting an amplitude associated with at least one of the messages, wherein the adjusting is performed as a function of time.
 33. The method of claim 31, further comprising: adjusting a width associated with at least one of the messages, wherein the adjusting is performed as a function of time.
 34. The method of claim 31, further comprising: adjusting a transmission time associated with a time that at least one of the messages travels between the pair of the elements, wherein the adjusting is performed as a function of time.
 35. The method of claim 31, wherein each of the messages is associated with an amplitude, and a causing of a given element of the plurality of elements to send is performed by the given element if a combination of amplitudes associated with a set of messages received by the given element is above a threshold.
 36. The method of claim 35, wherein the set of messages is received during a window of time.
 37. The method of claim 36, wherein a message received outside of the window is not included in the combination.
 38. The method of claim 36, wherein the window starts an amount of time after a prior sending of a message and ends after a time that is a width associated with a particular message.
 39. A system comprising: an active computing element capable of sending and receiving messages; the active computing element being associated with a threshold, wherein if a combination of messages received is greater than the threshold, the active computing element sends a message; and the active computing element also being associated with a refractory period, wherein after sending a first message, the active computing element waits until after the refractory period passes prior to sending a second message.
 40. The system of claim 39, wherein the active computing element comprises an amplifier having an input and an output; a positive feed from the output to the input; and a switch for ending the positive feedback.
 41. The system of claim 40, wherein the amplifier includes at least two stages, the first outputs an inverted signal, which is a signal that is inverted with respect to the input signal; and the second stage inverts the inverted signal output of the first stage.
 42. The system of claim 40, wherein the positive feedback includes at least a capacitor.
 43. The system of claim 42, wherein the output controls a gate voltage of an field effect transistor that drains the capacitor.
 44. The system of claim 39, wherein said combination is a sum.
 45. A system comprising: an active computing element capable of sending and receiving messages; the active computing element being associated with a threshold, wherein if a combination of messages received at some time is less than the threshold, the active computing element sends a message; and the active computing element also being associated with a refractory period, wherein after sending a first message, the active computing element waits until after the refractory period passes prior to sending a second message.
 46. A system comprising: an active computing element capable of sending and receiving messages; the active computing element being associated with a threshold interval, wherein if a combination of messages received at some time is outside the range of a lower threshold and upper threshold, the active computing element sends a message; and the active computing element also being associated with a refractory period, wherein after sending a first message, the active computing element waits until after the refractory period passes prior to sending a second message.
 47. A system comprising: an active computing element capable of sending and receiving messages; the active computing element being associated with a threshold interval, wherein if a combination of messages received at some time is inside the range of a lower threshold and upper threshold, the active computing element sends a message; and the active computing element also being associated with a refractory period, wherein after sending a first message, the active computing element waits until after the refractory period passes prior to sending a second message.
 48. A method comprising: building a set of machines, wherein each machine includes at least a collection of one or more active elements connected to one or more of other active elements of the collection, wherein each active element is capable of sending and receiving messages.
 49. The method of claim 48, further comprising: determining a value for an overall ability of a machine from the set to represent a given output based on a given input.
 50. The method of claim 49, further comprising: storing the value; and randomly choosing two machines from the set, wherein the process of randomly choosing is performed in a manner such that a probability of selecting a particular machine is proportional to the overall ability associated with the particular machine.
 51. The method of claim 50, further comprising: randomly choosing whether to move a group of active elements from a first one of the two machines chosen to a second one of the two machines chosen.
 52. The method of claim 50, further comprising: randomly choosing whether to change a parameter of a first one of the two machines.
 53. The method of claim 49, wherein an execution speed of a given machine from the set contributes to the overall ability of the given machine.
 54. The method of claim 49, wherein a number representing how many active elements are in a given machine from the set contributes to the overall ability of the given machine.
 55. The method of claim 49, wherein a number representing how many couplings are in a given machine of the set contributes to the overall ability of the given machine.
 56. The method of claim 49, wherein a computational accuracy of a given machine from the set contributes to the overall ability of the given machine.
 57. The method of claim 48, further comprising: determining a value for an overall ability of a machine to represent a given output based on a given input; storing the value; randomly choosing two machines from the set, wherein the process of randomly choosing is performed in a manner such that a probability of selecting a particular machine is proportional to the overall ability associated with the particular machine; randomly choosing a first number; if the first number is less than a first threshold moving a group of active elements from a first one of the two machines chosen to a second one of the two machines chosen; randomly choosing a second number; if the second number is less than a second threshold changing a parameter of the first one of the two machine; randomly choosing a third number; if the third number is less than a third threshold changing a parameter of the second one of the two machines.
 58. The method of claim 48, the building is performed by at least for each machine, constructing at least one input module, at least one output module, and one or more internal modules, wherein the at least one input module, the at least one output module, and one or more internal modules are connected to one another by external connections; for each machine, randomly choosing a number of modules therein; for each module, randomly choosing a number of active elements; for each active element, randomly choosing a refractory period, which is a time period between when the active element receives a first message and is capable of sending a second message; for each active element, randomly choosing a number of connections; for each connection between two active elements, randomly choosing a message width; for each connection between two active elements, randomly choosing an amplitude associated with messages traveling on the connection; for each active element, randomly choosing a threshold, wherein if a combination of amplitudes of incoming messages is greater than the threshold, the active element sends a message; and for each connection between two active elements, randomly choosing a transmission time, which is a time between a sending of a message and a receiving of the message.
 59. The method of claim 48, the build is performed by at least for each machine, constructing at least one input module, at least one output module, and one or more internal modules, wherein the at least one input module, the at least one output module, and one or more internal modules are connected to one another by external connections; for each machine, randomly choosing a number of modules therein; for each module, randomly choosing a number of active elements; for each active element, randomly choosing a refractory period, which is a time period between when the active element receives a first message and is capable of sending a second message; for each active element, randomly choosing a number of connections; for each connection between two active elements, randomly choosing a message width; for each connection between two active elements, randomly choosing an amplitude associated with messages traveling on the connection; for each active element, randomly choosing a threshold, wherein if a combination of amplitudes of incoming messages is less than the threshold, the active element sends a message; and for each connection between two active elements, randomly choosing a transmission time, which is a time between a sending of a message and a receiving of the message.
 60. The method of claim 48, further comprising: for each of at least two machines, choosing how many modules to switch; for each of the at least two machines, choosing which modules to switch based on how many modules were chosen; for each of the at least two machines, switching modules chosen to be switched, which are associated with a first of the at least two modules, with modules chosen to be switched that are associated with a second of the at least two machines. 